home *** CD-ROM | disk | FTP | other *** search
/ Enter 2006 September / Enter 09 2006.iso / Internet / SpamExperts Home 1.1 / SpamExperts Home.exe / lib / spamexperts.modules / spambayes / Version.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2006-07-14  |  10.6 KB  |  368 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Simple version repository for SpamBayes core, and our main apps.
  5.  
  6. Also has the ability to load this version information from a remote location
  7. (in that case, we actually load a "ConfigParser" version of the file to
  8. avoid importing code we can\'t trust.)  This allows any app to check if there
  9. is a later version available.
  10.  
  11. The makefile process for the website will execute this as a script, which
  12. will generate the "ConfigParser" version for the web.
  13. '''
  14. import string
  15. import re
  16. from types import StringType
  17.  
  18. try:
  19.     _
  20. except NameError:
  21.     
  22.     _ = lambda arg: arg
  23.  
  24. LATEST_VERSION_HOME = 'http://spambayes.sourceforge.net/download/Version.cfg'
  25. DEFAULT_DOWNLOAD_PAGE = 'http://spambayes.sourceforge.net/windows.html'
  26. versions = {
  27.     'Download Page': DEFAULT_DOWNLOAD_PAGE,
  28.     'Apps': {
  29.         'Outlook': {
  30.             'Description': 'SpamBayes Outlook Addin' },
  31.         'POP3 Proxy': {
  32.             'Description': 'SpamBayes POP3 Proxy' } } }
  33.  
  34. def get_version(app = None, version_dict = None):
  35.     '''Get SBVersion object based on the version info in the supplied dict.'''
  36.     ver = SBVersion()
  37.     if version_dict is not None:
  38.         dict = version_dict
  39.         if app is not None:
  40.             
  41.             try:
  42.                 dict = version_dict['Apps'][app]
  43.             except KeyError:
  44.                 pass
  45.             except:
  46.                 None<EXCEPTION MATCH>KeyError
  47.             
  48.  
  49.         None<EXCEPTION MATCH>KeyError
  50.         
  51.         try:
  52.             version = dict['Version']
  53.             
  54.             try:
  55.                 ver_num = float(version)
  56.                 dot = version.find('.')
  57.                 ver_frac_part = version[dot + 1:]
  58.                 if len(ver_frac_part) > 1:
  59.                     version = version[0:dot] + '.' + ver_frac_part[0] + '.' + ver_frac_part[1:]
  60.             except ValueError:
  61.                 pass
  62.  
  63.             ver = SBVersion(version, version_dict['Date'])
  64.         except KeyError:
  65.             pass
  66.         except:
  67.             None<EXCEPTION MATCH>KeyError
  68.         
  69.  
  70.     None<EXCEPTION MATCH>KeyError
  71.     return ver
  72.  
  73.  
  74. def get_download_page(app = None, version_dict = None):
  75.     if version_dict is None:
  76.         version_dict = versions
  77.     
  78.     dict = version_dict
  79.     if app is not None:
  80.         
  81.         try:
  82.             dict = version_dict['Apps'][app]
  83.         except KeyError:
  84.             pass
  85.         except:
  86.             None<EXCEPTION MATCH>KeyError
  87.         
  88.  
  89.     None<EXCEPTION MATCH>KeyError
  90.     
  91.     try:
  92.         return dict['Download Page']
  93.     except KeyError:
  94.         return DEFAULT_DOWNLOAD_PAGE
  95.  
  96.  
  97.  
  98. def get_current_version():
  99.     return SBVersion()
  100.  
  101.  
  102. class SBVersion:
  103.     '''Version numbering for SpamBayes releases.
  104.     A version number consists of two or three dot-separated numeric
  105.     components, with an optional "pre-release" tag on the end.  The
  106.     pre-release tag consists of the designations \'a\' (for alpha),
  107.     \'b\' (for beta), or \'rc\' (for release candidate) followed by a number.
  108.     If the numeric components of two version numbers are equal, then one
  109.     with a pre-release tag will always be deemed earlier (lesser) than
  110.     one without.
  111.  
  112.     The following are valid version numbers (shown in the order that
  113.     would be obtained by sorting according to the supplied cmp function):
  114.  
  115.         0.4       0.4.0  (these two are equivalent)
  116.         0.4.1
  117.         0.5a1
  118.         0.5b3
  119.         0.5
  120.         0.9.6
  121.         1.0
  122.         1.0.4a3
  123.         1.0.4b1
  124.         1.0.4rc2
  125.         1.0.4
  126.  
  127.     The following are examples of invalid version numbers:
  128.  
  129.         1
  130.         2.7.2.2
  131.         1.3.a4
  132.         1.3pl1
  133.         1.3c4
  134.  
  135.     A date may also be associated with the version, typically to track the
  136.     date when the release was made public.  The date is specified as a string,
  137.     and is only used in formatting the long version of the version string.
  138.     '''
  139.     
  140.     def __init__(self, vstring = None, date = None):
  141.         import spambayes
  142.         if vstring:
  143.             self.parse(vstring)
  144.         else:
  145.             self.parse(spambayes.__version__)
  146.         if date:
  147.             self.date = date
  148.         else:
  149.             self.date = spambayes.__date__
  150.  
  151.     
  152.     def __repr__(self):
  153.         return "%s('%s', '%s')" % (self.__class__.__name__, str(self), self.date)
  154.  
  155.     version_re = re.compile('^(\\d+) \\. (\\d+) (\\. (\\d+))? (([ab]|rc)(\\d+))?\\+?$', re.VERBOSE)
  156.     
  157.     def parse(self, vstring):
  158.         match = self.version_re.match(vstring)
  159.         if not match:
  160.             raise ValueError, "invalid version number '%s'" % vstring
  161.         
  162.         (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 6, 7)
  163.         if not patch:
  164.             patch = '0'
  165.         
  166.         if not prerelease:
  167.             releaselevel = 'final'
  168.             serial = 0
  169.         else:
  170.             serial = string.atoi(prerelease_num)
  171.             if prerelease == 'a':
  172.                 releaselevel = 'alpha'
  173.             elif prerelease == 'b':
  174.                 releaselevel = 'beta'
  175.             elif prerelease == 'rc':
  176.                 releaselevel = 'candidate'
  177.             
  178.         self.version_info = tuple(map(string.atoi, [
  179.             major,
  180.             minor,
  181.             patch]) + [
  182.             releaselevel,
  183.             serial])
  184.  
  185.     
  186.     def __str__(self):
  187.         if self.version_info[2] == 0:
  188.             vstring = string.join(map(str, self.version_info[0:2]), '.')
  189.         else:
  190.             vstring = string.join(map(str, self.version_info[0:3]), '.')
  191.         releaselevel = self.version_info[3][0]
  192.         if releaselevel != 'f':
  193.             if releaselevel == 'a':
  194.                 prerelease = 'a'
  195.             elif releaselevel == 'b':
  196.                 prerelease = 'b'
  197.             elif releaselevel == 'c':
  198.                 prerelease = 'rc'
  199.             
  200.             vstring = vstring + prerelease + str(self.version_info[4])
  201.         
  202.         return vstring
  203.  
  204.     
  205.     def __cmp__(self, other):
  206.         if isinstance(other, StringType):
  207.             other = SBVersion(other)
  208.         
  209.         return cmp(self.version_info, other.version_info)
  210.  
  211.     
  212.     def get_long_version(self, app_name = None):
  213.         if app_name is None:
  214.             app_name = 'SpamBayes'
  215.         
  216.         return _('%s Version %s (%s)') % (app_name, str(self), self.date)
  217.  
  218.  
  219.  
  220. try:
  221.     import ConfigParser
  222.     
  223.     class MySafeConfigParser(ConfigParser.SafeConfigParser):
  224.         
  225.         def optionxform(self, optionstr):
  226.             return optionstr
  227.  
  228.  
  229. except AttributeError:
  230.     MySafeConfigParser = None
  231.  
  232.  
  233. def fetch_latest_dict(url = LATEST_VERSION_HOME):
  234.     if MySafeConfigParser is None:
  235.         raise RuntimeError, 'Sorry, but only Python 2.3+ can trust remote config files'
  236.     
  237.     import urllib2
  238.     options = options
  239.     import spambayes.Options
  240.     server = options[('globals', 'proxy_server')]
  241.     if server != '':
  242.         if ':' in server:
  243.             (server, port) = server.split(':', 1)
  244.             port = int(port)
  245.         else:
  246.             port = 8080
  247.         if options[('globals', 'proxy_username')]:
  248.             user_pass_string = '%s:%s' % (options[('globals', 'proxy_username')], options[('globals', 'proxy_password')])
  249.         else:
  250.             user_pass_string = ''
  251.         proxy_support = urllib2.ProxyHandler({
  252.             'http': 'http://%s@%s:%d' % (user_pass_string, server, port) })
  253.         opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler)
  254.         urllib2.install_opener(opener)
  255.     
  256.     stream = urllib2.urlopen(url)
  257.     cfg = MySafeConfigParser()
  258.     cfg.readfp(stream)
  259.     ret_dict = { }
  260.     apps_dict = ret_dict['Apps'] = { }
  261.     for sect in cfg.sections():
  262.         if sect == 'SpamBayes':
  263.             target_dict = ret_dict
  264.         else:
  265.             target_dict = apps_dict.setdefault(sect, { })
  266.         for opt in cfg.options(sect):
  267.             val = cfg.get(sect, opt)
  268.             target_dict[opt] = val
  269.         
  270.     
  271.     return ret_dict
  272.  
  273. compat_apps = {
  274.     'Outlook': {
  275.         'Description': 'SpamBayes Outlook Addin' },
  276.     'POP3 Proxy': {
  277.         'Description': 'SpamBayes POP3 Proxy' } }
  278. shared_cfg_opts = {
  279.     'Download Page': 'http://spambayes.sourceforge.net/windows.html' }
  280.  
  281. def _write_cfg_opts(stream, this_dict):
  282.     for name, val in this_dict.items():
  283.         if type(val) == type(''):
  284.             val_str = repr(val)[1:-1]
  285.         elif type(val) == type(0.0):
  286.             val_str = str(val)
  287.         elif type(val) == type({ }):
  288.             val_str = None
  289.         else:
  290.             print 'Skipping unknown value type: %r' % val
  291.             val_str = None
  292.         if val_str is not None:
  293.             stream.write('%s:%s\n' % (name, val_str))
  294.             continue
  295.     
  296.  
  297.  
  298. def _make_compatible_cfg_section(stream, key, ver, this_dict):
  299.     stream.write('[%s]\n' % key)
  300.     ver_num = float(ver.version_info[0])
  301.     ver_num += float(ver.version_info[1] * 0.10000000000000001)
  302.     ver_num += float(ver.version_info[2] * 0.01)
  303.     releaselevel = ver.version_info[3][0]
  304.     if releaselevel == 'a':
  305.         prerelease_offset = 0.001 - float(ver.version_info[4]) * 1.0000000000000001e-005
  306.     elif releaselevel == 'b':
  307.         prerelease_offset = 0.00050000000000000001 - float(ver.version_info[4]) * 1.0000000000000001e-005
  308.     elif releaselevel == 'c':
  309.         prerelease_offset = 0.0001 - float(ver.version_info[4]) * 1.0000000000000001e-005
  310.     else:
  311.         prerelease_offset = 0.0
  312.     ver_num -= prerelease_offset
  313.     stream.write('Version:%s\n' % str(ver_num))
  314.     stream.write('BinaryVersion:%s\n' % str(ver_num))
  315.     stream.write('Date:%s\n' % ver.date)
  316.     _write_cfg_opts(stream, this_dict)
  317.     desc_str = '%%(Description)s Version %s (%%(Date)s)' % str(ver)
  318.     stream.write('Full Description:%s\n' % desc_str)
  319.     stream.write('Full Description Binary:%s\n' % desc_str)
  320.     _write_cfg_opts(stream, versions)
  321.     stream.write('\n')
  322.  
  323.  
  324. def _make_cfg_section(stream, ver):
  325.     stream.write('[SpamBayes]\n')
  326.     stream.write('Version:%s\n' % str(ver))
  327.     stream.write('Date:%s\n' % ver.date)
  328.     _write_cfg_opts(stream, versions)
  329.     stream.write('\n')
  330.  
  331.  
  332. def make_cfg(stream):
  333.     stream.write('# This file is generated from spambayes/Version.py - do not edit\n')
  334.     ver = get_current_version()
  335.     _make_cfg_section(stream, ver)
  336.     for appname in compat_apps:
  337.         _make_compatible_cfg_section(stream, appname, ver, versions['Apps'][appname])
  338.     
  339.  
  340.  
  341. def main(args):
  342.     import sys
  343.     if '-g' in args:
  344.         make_cfg(sys.stdout)
  345.         sys.exit(0)
  346.     
  347.     v_this = get_current_version()
  348.     print 'Current version:', v_this.get_long_version()
  349.     print 
  350.     print 'Fetching the lastest version information...'
  351.     
  352.     try:
  353.         latest_dict = fetch_latest_dict()
  354.     except:
  355.         print 'FAILED to fetch the latest version'
  356.         import traceback
  357.         traceback.print_exc()
  358.         sys.exit(1)
  359.  
  360.     v_latest = get_version(version_dict = latest_dict)
  361.     print 
  362.     print 'Latest version:', v_latest.get_long_version()
  363.  
  364. if __name__ == '__main__':
  365.     import sys
  366.     main(sys.argv)
  367.  
  368.